# -*- coding: UTF-8 -*-
##############################################
##############################################
##############################################
#https://sites.google.com/site/raptorvsnightawk/_imagem do jogo
###############################################
###############################################
###############################################
###############################################
# Referencia do Códiogo utilizado para criação do fundo: parallax_starfield. Este código pode ser encontrado no site -> http://www.pygame.org/project-Cool+Parallax+Starfield-1845-3227.html ; http://goo.gl/8ER6A
###############################################
###############################################
###############################################
# O tiro da nave foi baseado no código encontrado no site: http://defpython.blogspot.com/search/label/PyGame 
###############################################
###############################################
###############################################
#A movimentação do inimigo foi baseado em um codigo produzido por Danilo M. Gomes
###############################################
###############################################
############################################### 

import pygame # Importa a biblioteca pygame
from random import randrange, choice # randrange: retornar um elemento selecionado aleatoriamente. ### from random import choice: Este comando irá importar a função de escolha do módulo random. 
from pygame.locals import* # importa tudo que tem no módulo.todas as funções e métodos do modulo importado serão variaveis locais do meu modulo.
import sys, os # O módulo sys contém funcionalidades específicas do sistema operacional. ### O OS módulo oferece dezenas de funções para interagir com o sistema operacional:
from sys import exit # Serve para fechar o pygame

largura = 640
altura = 480 
MAX_STARS  = 250
STAR_SPEED = 2

def init_stars(tela): 

	""" Create the starfield """
	""" Criar o campo estrelado """

	global stars # O global indica que modificaremos os valores dessas variáveis dentro de funções. 

	stars = [] # lista contendo outras listas.

	for a in range(MAX_STARS):#Cria uma lista de números inteiros

		# A star is represented as a list with this format: [X,Y,speed]
		# Uma estrela é representada como uma lista com esse formato: [X,Y,velocidade]

		star = [randrange(0,tela.get_width() - 1), # tela.get_width(): Obter a largura da superfície.
			randrange(0,tela.get_height() - 1), # tela.get_height(): Obter a altura da superfície.
			choice([1,2,3])] # Choice: Utiliza o modo radom para escolher de forma aleatoria.
		stars.append(star) # Manda as informações escolhidas aleatoriamente para lista

def move_and_draw_stars(tela):

	""" Move and draw the stars in the given tela """
	""" Mover e desenhar as estrelas na tela  """

	global stars

	for star in stars:

		star[1] += star[2]

		# If the star hit the bottom border then we reposition it in the top of the tela with a random X coordinate.
		# Se a estrela atingiu a borda inferior então reposicionar-la no topo da tela com uma coordenada X aleatória.

		if star[1] >= tela.get_height():

			star[1] = 0 # voltar a cordenada 0 no eixo y.
			star[0] = randrange(0,639) # Delimitador das cordenadas do eixo x.
			star[2] = choice([1,2,3]) # lista que determina as cores das estrelas. 

		# Adjust the star color acording to the speed.
		# Ajuste da cor das estrelas de acordo com a velocidade.

		# The slower the star, the darker should be its color.
		# A estrela mais lenta, deve ter a cor mais escura.
		
		if star[2] == 1: # determinação da estrela mais lenta que determina a cor mais escura

			color = (100,100,100)

		elif star[2] == 2: 

			color = (190,190,190)

		elif star[2] == 3:

			color = (255,255,255)

      		# Draw the star as a rectangle.
      		# Desenhar a estrela como um retângulo.

		# The star size is proportional to its speed.
		# O tamanho da estrela é proporcional à sua velocidade.

		tela.fill(color,(star[0],star[1],star[2],star[2])) # Vai preencher a tela com estrelas

def main():

########## Carregando imagens e sons ####################################### 
	
	branco = (255,255,255)
	preto = (0,0,0)
	vermelho = (255,0,0)

	########## Outros eventos ##########

	def som():
		detonando.play()
		return
	pygame.init() # Inicia todas as funções da biblioteca pygame 
	detonando = pygame.mixer.Sound("./arquivos/explode.ogg")
	somtiro = pygame.mixer.Sound("./arquivos/missile_explosion.ogg")
	somtiro1 = pygame.mixer.Sound("./arquivos/empire_laser.wav") 
	audio = pygame.mixer.Sound("./arquivos/SpaceBombers.ogg")
	audio.play(-1) # Repetição infinita da musica
	pygame.key.set_repeat(100, 10) # Permite a repetição de eventos do teclado.    
	tela = pygame.display.set_mode((largura,altura)) # Dimensão da tela. 
	pygame.display.set_caption("Jetfire-Combat_UFAL")
	posicao_jogador_eixo_y, posicao_jogador_eixo_x = 370, 290 # Coordenadas iniciais da nave do jogador.
	velocidade_do_tiro_jogador = 60 # Velocidade do tiro_jogador
	pygame.mouse.set_cursor(*pygame.cursors.broken_x)# Transforma o pontero do mouse em um X:

	########## Carregamento e conversão de imagens ##########

	voltar = pygame.image.load('./arquivos/botao_voltar.gif')
	exiti = pygame.image.load('./arquivos/exit.jpg')
	fundo_desen = pygame.image.load('./arquivos/fundo_desen.jpg')
	desenvolvedores = pygame.image.load('./arquivos/desenvolvedores.png')
	fundo_menu = pygame.image.load('./arquivos/fundo.jpg')
	iniciar = pygame.image.load('./arquivos/botao_start.gif')	
	carregando = pygame.image.load('./arquivos/loading3.gif') # pygame.imagem.load: Carregar uma imagem de um arquivo de origem. Você pode passar um nome de arquivo ou um objeto Python como arquivo.
	meteoro = pygame.image.load('./arquivos/Meteor.png')
	fundo_destruido = os.path.join("./arquivos/fundo_transparente.png") # Adicionando o desenho ao fundo
	fundo = pygame.image.load(fundo_destruido).convert_alpha() # Carregando o desenho do fundo e transformando os byts da imagem em pixels alpha
	nave_destruido = os.path.join("./arquivos/car_u.png")
	nave = pygame.image.load(nave_destruido).convert_alpha()# Convert_alpha: Alterar o formato do pixel de uma imagem incluindo pixel por alphas. Converter em alfas é um tipo de transparencia que tem um não-branco como cor de fundo.
	tiro_inimigo_destruido = os.path.join("./arquivos/laserr.png")
	tiro_inimigo = pygame.image.load(tiro_inimigo_destruido)  
	tiro_jogador_destruido = os.path.join("./arquivos/laser.png") # os.path: Este módulo implementa algumas funções úteis sobre caminhos. Join = Junte-se a um ou mais componentes
	tiro_jogador = pygame.image.load(tiro_jogador_destruido).convert_alpha()
	inimigo_destruido = os.path.join("./arquivos/inimigo.png")
	inimigo = pygame.image.load(inimigo_destruido).convert_alpha()
	inimigo_explo_destruido = os.path.join("./arquivos/explosionn.png")
	inimigo_explo = pygame.image.load(inimigo_explo_destruido).convert_alpha()
	jogador_explo_destruido = os.path.join("./arquivos/explosionn.png")
	jogador_explo = pygame.image.load(jogador_explo_destruido).convert_alpha()
	

	########## Estrutura de texo ##########

	tamanho1 = pygame.font.SysFont('Arial',10) # Escolhe a fonte  o tamanho.
	tamanho2 = pygame.font.SysFont('Tahoma',15) # Escolhe a fonte  o tamanho.
	tamanho3 = pygame.font.SysFont('Arial Black',20)#
	tamanho4 = pygame.font.SysFont('Arial',13)
	pontos = tamanho2.render('Pontos:', 1, branco)# Redenriza a fonte com a cor branca e o texto
	vida_do_inimigoo0 = tamanho2.render('Vida do inimigo:', 1, branco)
	pontos_vida1 = tamanho2.render('100', 1, branco)
	pontos_vida2 = tamanho2.render('Pontos de Vida:', 1, branco)
	desenvolvedoress = tamanho1.render('DESENVOLVEDORES',1,branco)		
	menu_desen = tamanho3.render('DESENVOLVEDORES',1, branco)
	desenvolvedor1 = tamanho3.render('Itamar Reis Wanderley',1, branco)
	desenvolvedor3 = tamanho3.render('Wisnner Franklin dos Santos Silva',1, branco)
	email_desen1 = tamanho4.render('itamar_reis@hotmail.com',1, preto)
	email_desen3 = tamanho4.render('wisnnerf@hotmail.com',1 , preto)	
	contador_tempo = tamanho2.render('Tempo:',1 , branco)

	########## Jogador ganha ##########

	fim_do_jogo_vitoria = tamanho3.render('Parabens, o tempo de termino do jogo', 1, branco)
	fim_do_jogo_vitoria1 = tamanho3.render('foi de:', 1, branco )
	fim_do_jogo_vitoria2 = tamanho3.render('milisegundos', 1, branco)
	fim_do_jogo_vitoria3 = tamanho2.render('  Pressione Esc para sair ou F1 para voltar ao menu principal!', 1, vermelho)

	########## Jogador perde ##########

	fim_do_jogo_derrota = tamanho3.render('Infelizmente nao foi dessa vez', 1, branco)
	fim_do_jogo_derrota1 = tamanho3.render('Voce foi derrotado em:', 1, branco)
	fim_do_jogo_derrota2 = tamanho3.render('milisegundos', 1, branco)
	fim_do_jogo_derrota3 = tamanho2.render('  Pressione Esc para sair ou F1 para voltar ao menu principal!', 1, vermelho)


########## Fim do carregamento de imagens e sons #####################################################
  
########## Início dos contadores do jogo #############################################################

	controle_de_tempo = pygame.time.Clock() # Criar um objeto para ajudar a controlar o tempo. 

				   # Tempo em pygame é representado em milissegundos (1 / 1000 segundos). A maioria das plataformas têm uma resolução limitada do tempo de cerca de 10 milissegundos. Esta resolução, em milissegundos, é dada no TIMER_RESOLUTION constante.

	jogo_para_menu = 0
	relogio = 0
	init_stars(tela) # Chama a primeira função do jogo 
	menu_desenvolvedores_sair = 0
	menu_iniciar = 0
	menu_desenvolvedores = 0
	menu_sair = 0
	vida_do_inimigo = 1000
	vida_do_jogador = 1000
	contador_de_pontos = 0 # Contador de pontuação
	relogio1 = 10 # Relógio do load
	lado_direito_e_esquerdo = 1
	posicao_inimigo_eixo_x = 0 # Posição da minha nave no eixo x
	posicao_inimigo_eixo_y = 0 # Posição da minha nave no eixo y
	posicao_do_cometa_no_eixo_x = 0 # Posição do cometa(carregamento da tela) no eixo x 
	posicao_do_cometa_no_eixo_y = 150 # Posição do cometa(carregamento da tela) no eixo y)
	contador_do_cometa = 0
	posicao_inimigo_exo_x = 0
	
########## Fim dos contadores do jogo ##########################################################################

	while 1: # while principal

		controle_de_tempo.tick(50) # Utilização da variável criada acima para ajudar a controlar o tempo.

########## Menu do jogo ###########################################################################################

		while 1:
			
			if menu_sair >= 1:

				exit()
		
	########## Entrando na tela dos desenvolvedores ##########

			if menu_desenvolvedores >= 1:

				while 1:

					if menu_desenvolvedores_sair >= 1:

						menu_desenvolvedores_sair = 0

						menu_desenvolvedores = 0 

						break

                                        for acontecimentos in pygame.event.get(): # pygame.event.get(): se refere a captura de eventos do computador fornecendo dessa forma uma tupla.

                                                if acontecimentos.type == QUIT: # se o tipo de acontecimentos for igual a 'QUIT' então exit. 

                                                        exit()			

						elif acontecimentos.type == KEYDOWN:# Evento referente a botão precionado.

                                        		if acontecimentos.key == K_ESCAPE: # K_ESCAPE = botão fechar da janela do jogo: 

                                                		exit()

						elif acontecimentos.type == MOUSEBUTTONDOWN: # O tipo de acontecimentos se refere ao maose.

							p = pygame.mouse.get_pos() # Cria uma tupla com o valor das cordenadas do mouse(x,y)  

							if 513 <= p[0] <= 622 and 405 <= p[1] <= 450:

								posicao = pygame.mouse.get_pressed()
								menu_desenvolvedores_sair = menu_desenvolvedores_sair + posicao[0]

					tela.blit(fundo_desen,(0,0))
					tela.blit(menu_desen, (170,10))
					tela.blit(desenvolvedor1,(20,140))
					tela.blit(email_desen1, (20,165))
					tela.blit(desenvolvedor3, (20,180))
					tela.blit(email_desen3, (20,205))
					tela.blit(voltar, (500,400))
					pygame.display.update() # pygame.display.flip()
						
	########## Fim da tela dos desenvolvedores ##########
			
			if menu_iniciar >= 1:

                                break
			
    			for acontecimentos in pygame.event.get():

        			if acontecimentos.type == QUIT:

            				exit()

				if acontecimentos.type == KEYDOWN:

					if acontecimentos.key == K_ESCAPE:

						exit() 

				if acontecimentos.type == MOUSEBUTTONDOWN:

					p = pygame.mouse.get_pos() # Cria uma tupla com o valor das cordenadas do mouse(x,y)

					if 7 <= p[0] <= 105 and 11 <= p[1] <= 55: # Representa as dimenções da imagem do botão inciar

						posicao = pygame.mouse.get_pressed() # Indica qual o botão do mouse foi precionado
						menu_iniciar = posicao[0] # Seleciona o primeiro botão do mouse que quando clicado é igaul a 1 e quando não igual a 0.
						menu_iniciar = menu_iniciar + 1

				        if 30 <= p[0] <= 80 and 75 <= p[1] <= 120:

                                                posicao = pygame.mouse.get_pressed()
                                                menu_desenvolvedores = posicao[0]
                                                menu_desenvolvedores = menu_desenvolvedores + 1

					if 3 <= p[0] <= 110 and 121 <= p[1] <= 130:

						posicao = pygame.mouse.get_pressed()
                                                menu_desenvolvedores = posicao[0]
                                                menu_desenvolvedores = menu_desenvolvedores + 1

					if 9 <= p[0] <= 109 and 155 <= p[1] <= 198:

						posicao = pygame.mouse.get_pressed()
						menu_sair = posicao[0]
						menu_sair = menu_sair + 1					

			tela.blit(fundo_menu, (0,0))
			tela.blit(iniciar, (0,0))
			tela.blit(desenvolvedores,(30,75))
			tela.blit(desenvolvedoress,(5,120))
			tela.blit(exiti,(10,155))
			pygame.mouse.set_visible (1)
			pygame.display.update() # pygame.display.flip() #Atualizar a tela
    
########## Fim do menu do jogo ###########################################################################################
	        
	# Lock the framerate at 50 FPS
        # Ver os framarate com 50  FPS

########## Início da movimentação automática do load ###########################################################################################

	########## Carregar o jogo(tela de load) ##########
	
		while contador_do_cometa < 2000:

	                if posicao_do_cometa_no_eixo_x >= 590:

        	                lado_direito_e_esquerdo = 0 # 0 = False

                	if posicao_do_cometa_no_eixo_x <= 150:

                        	lado_direito_e_esquerdo = 1 # 1 = True

                	if lado_direito_e_esquerdo != 0:

                        	posicao_do_cometa_no_eixo_x = posicao_do_cometa_no_eixo_x + 10

                       	if lado_direito_e_esquerdo != 1:

                        	posicao_do_cometa_no_eixo_x = posicao_do_cometa_no_eixo_x - 10
				posicao_inimigo_exo_x = posicao_inimigo_exo_x +  0.6
				
             
			for acontecimentos in pygame.event.get():

				if acontecimentos.type == QUIT:

					exit()

				if acontecimentos.type == KEYDOWN:

					if acontecimentos.key == K_ESCAPE:

						exit()

			tela.fill(preto)
			tela.blit(carregando,(0, 0))
			tela.blit(meteoro,(posicao_do_cometa_no_eixo_x,posicao_do_cometa_no_eixo_y))
			pygame.display.update() # pygame.display.flip()
			contador_do_cometa = contador_do_cometa + 1

	########## Fim do carregar o jogo(tela de load) ##########


########## Início da movimentação automática do inimigo ###########################################################################################

		if posicao_inimigo_eixo_x >= 543:

			lado_direito_e_esquerdo = 0 # 0 = False
			
				
		if posicao_inimigo_eixo_x <= 1:

			lado_direito_e_esquerdo = 1 # 1 = True
		
		if lado_direito_e_esquerdo != 0:

			posicao_inimigo_eixo_x = posicao_inimigo_eixo_x +  0.8
			posicao_inimigo_exo_x = posicao_inimigo_exo_x +  0.6
			posicao_inimigo_eixo_y = posicao_inimigo_eixo_y + 0.023
			
		if lado_direito_e_esquerdo != 1: 

			posicao_inimigo_eixo_x = posicao_inimigo_eixo_x - 0.8
			
			
			
	
########## Fim da movimentação automática do inimigo ###########################################################################################

########## Início da captura dos eventos, movimentos, tiros, quit, etc ###########################################################################################

		acontecimentos_do_tiro_jogador_inimigo = pygame.key.get_pressed() # Indica qual o botão do teclado foi precionado
 		acontecimentos_do_tiro_jogador_jogador = pygame.key.get_pressed() # Indica qual o botão do teclado foi precionado

		for acontecimentos in pygame.event.get(): # pygame.event.get(): se refere a captura de eventos do computador fornecendo dessa forma uma tupla. ## pygame.event = módulo pygame para interagir com eventos e filas. ## get(): É responsável pelo retorno de uma lista com tudo que se passa em um dado estante.
					
			pass # Serve para limpar a lista produzida pela função get().

		if acontecimentos.type == QUIT:

			exit()

		if acontecimentos.type == KEYDOWN: # Evento referente a botão precionado. 

	 		if acontecimentos.key == K_UP:

				if  posicao_jogador_eixo_y >= 3:

					posicao_jogador_eixo_y = posicao_jogador_eixo_y - 10

			if acontecimentos.key == K_DOWN:

				if posicao_jogador_eixo_y < 480 - (nave.get_size()[0]*1.3):#(get_size()[0]*1.3)Cria uma tupla com o tamanho da imagem

					posicao_jogador_eixo_y = posicao_jogador_eixo_y + 10

			if acontecimentos.key == K_LEFT:

				if posicao_jogador_eixo_x >= +5:

					posicao_jogador_eixo_x = posicao_jogador_eixo_x - 10

			if acontecimentos.key == K_RIGHT:

				if posicao_jogador_eixo_x < 680 -(nave.get_size()[1]*1.2):

					posicao_jogador_eixo_x = posicao_jogador_eixo_x + 10

			if acontecimentos.key == K_ESCAPE:

				exit()

		if acontecimentos_do_tiro_jogador_jogador[K_SPACE]: # Definimos o botão para esta condição

					somtiro1.play()
					tiro_jogador_p_eixo_y, tiro_jogador_p_eixo_x = posicao_jogador_eixo_y, posicao_jogador_eixo_x

      					while tiro_jogador_p_eixo_y >= 0: # O tiro_jogador chega até a posição 0 no eixo y. 

           					tela.blit(tiro_jogador, (tiro_jogador_p_eixo_x+32,tiro_jogador_p_eixo_y-40)) # Carregando o tiro_jogador, de acordo com a centralização da nave.
						tiro_jogador_p_eixo_y = tiro_jogador_p_eixo_y - velocidade_do_tiro_jogador # Velocidade do tiro_jogador.

                      				if posicao_inimigo_eixo_x-40 < tiro_jogador_p_eixo_x < posicao_inimigo_eixo_x+40 and tiro_jogador_p_eixo_y < posicao_inimigo_eixo_y+20:#determinando a condição da colisão. ## posicao_inimigo_eixo_y+20 = é a posição da nave inimiga 		                			tela.blit(fundo, (0,0)) #Carrega o fundo, com a mesma resolução da tela.
       	      					
						#	detonando.play()
							vida_do_inimigo = vida_do_inimigo - 5
							contador_de_pontos = contador_de_pontos + 1
							tela.blit(inimigo_explo,(posicao_inimigo_eixo_x,posicao_inimigo_eixo_y)) # Desenha a explosão inimigo ao coledir com o tiro_jogador.
	                				pygame.display.update() # Atualização da tela
						
							break
	
            					else:

							tela.blit(fundo, (0,0))
							pygame.display.update() # Atualização da tela

		if vida_do_jogador != 0: # Atira até que o jogador morra.

					somtiro.play()
					tiro_inimigo_p_eixo_y, tiro_inimigo_p_eixo_x = posicao_inimigo_eixo_y, posicao_inimigo_eixo_x # criação de duas variaveis com a posição da saida do tiro_jogador = as cordenas do inimigo

      					while tiro_inimigo_p_eixo_y <= 480: # O tiro_inimigo chega até a posição 480 no eixo y. 

           					tela.blit(tiro_inimigo, (tiro_inimigo_p_eixo_x+35,tiro_inimigo_p_eixo_y+130)) # Carregando o tiro_jogador, de acordo com a centralização da nave.
						tiro_inimigo_p_eixo_y = tiro_inimigo_p_eixo_y + velocidade_do_tiro_jogador # Velocidade do tiro_jogador.

                      				if posicao_jogador_eixo_x-40 < tiro_inimigo_p_eixo_x < posicao_jogador_eixo_x+40 and tiro_inimigo_p_eixo_y > posicao_jogador_eixo_y -20:#determinando a condição da colisão. ## posicao_inimigo_eixo_y+20 = é a posição da nave inimiga 		                			tela.blit(fundo, (0,0)) #Carrega o fundo, com a mesma resolução da tela.
       	      					
							vida_do_jogador = vida_do_jogador - 5
							tela.blit(jogador_explo,(posicao_jogador_eixo_x,posicao_jogador_eixo_y)) # Desenha a explosão inimigo ao coledir com o tiro_jogador.
							tela.blit(fundo, (0,0))
	                				pygame.display.update() # Atualização da tela
						
							break
	
            					else:

							tela.blit(fundo, (0,0))
							pygame.display.update() # Atualização da tela 
					
	########## O jogador perdeu ##########

		else:			

			detonando.play()

			while 1:

				posicao_jogador_eixo_x = -40 # Simulação da morte do jogador (cordenadas)
				posicao_jogador_eixo_y = -20 # Simulação da morte do jogador (cordenadas)
				controle_de_tempo.tick(50)

				for acontecimentos in pygame.event.get(): # pygame.event.get(): se refere a captura de eventos do computador fornecendo dessa forma uma tupla. ## pygame.event = módulo pygame para interagir com eventos e filas. ## get(): É responsável pelo retorno de uma lista com tudo que se passa em um dado estante.
					
					if acontecimentos.type == QUIT:

						exit()

					if acontecimentos.type == KEYDOWN:	

						if acontecimentos.key == K_ESCAPE:

							exit()

						if acontecimentos.key == K_F1:

							audio.stop() # Repetição infinita da musica
							main()

				if posicao_inimigo_eixo_x >= 543:

					lado_direito_e_esquerdo = 0 # 0 = False

				if posicao_inimigo_eixo_x <= 1:

					lado_direito_e_esquerdo = 1 # 1 = True   

				if lado_direito_e_esquerdo != 0:

					posicao_inimigo_eixo_x = posicao_inimigo_eixo_x +  0.6
					posicao_inimigo_exo_x = posicao_inimigo_exo_x +  0.6
					posicao_inimigo_eixo_y = posicao_inimigo_eixo_y + 0.023

				if lado_direito_e_esquerdo != 1: 

					posicao_inimigo_eixo_x = posicao_inimigo_eixo_x - 0.6
					
				tela.fill((0,0,0)) # Preencha a tela, de cor preta (0, 0, 0).
				move_and_draw_stars(tela) # Desenha as estrelas do fundo na tela.
				tela.blit(inimigo,(posicao_inimigo_eixo_x,posicao_inimigo_eixo_y))# Desenha o inimigo.
				tela.blit(vida_do_inimigoo0,(485,0)) # Conta de vida_do_inimigo 
				tela.blit(vida_do_inimigoo,(610,0)) # contador de vida_do_inimigo
				tela.blit(pontos,(0,0)) # Contador de pontos
				tela.blit(pontos1,(70,0)) # Contador de pontos 
				tela.blit(relogio_do_jogo,(60,460))
				tela.blit(contador_tempo,(1,460))
				tela.blit(tempo_do_jogo,(325,180)) #imprimir contador
				tela.blit(vida_do_jogadorr,(610,460)) # Contador de pontos de vida do jogador
				tela.blit(pontos_vida2,(500,460)) # Contador de pontos de vida do jogador
				tela.blit(fim_do_jogo_derrota,(150,150))
				tela.blit(fim_do_jogo_derrota1,(75,180))
				tela.blit(fim_do_jogo_derrota2,(395,180))
				tela.blit(fim_do_jogo_derrota3,(108,210))
				pygame.display.update() # pygame.display.flip().

	########## O jogador ganhou ##########

		if vida_do_inimigo == 0:
			
			detonando.play()

			while 1:

				posicao_inimigo_eixo_x = -40 # Simulação da morte do inimigo (cordenadas)
				posicao_inimigo_eixo_y = -20 # Simulação da morte do inimigo (cordenadas)
				controle_de_tempo.tick(50)							
				acontecimentos_do_tiro_jogador_jogador = pygame.key.get_pressed() # Indica qual o botão do teclado foi precionado

				for acontecimentos in pygame.event.get(): # pygame.event.get(): se refere a captura de eventos do computador fornecendo dessa forma uma tupla. ## pygame.event = módulo pygame para interagir com eventos e filas. ## get(): É responsável pelo retorno de uma lista com tudo que se passa em um dado estante.

					
					pass # Serve para limpar a lista produzida pela função get().

				if acontecimentos.type == QUIT:

					exit()

				elif acontecimentos.type == KEYDOWN: # Evento referente a botão precionado. 

			 		if acontecimentos.key == K_UP:

						if  posicao_jogador_eixo_y >= 3:

							posicao_jogador_eixo_y = posicao_jogador_eixo_y - 10
	
					if acontecimentos.key == K_DOWN:

						if posicao_jogador_eixo_y < 480 - (nave.get_size()[0]*1.3):#(get_size()[0]*1.3)Cria uma tupla com o tamanho da imagem

							posicao_jogador_eixo_y = posicao_jogador_eixo_y + 10

					if acontecimentos.key == K_LEFT:

						if posicao_jogador_eixo_x >= +5:

							posicao_jogador_eixo_x = posicao_jogador_eixo_x - 10

					if acontecimentos.key == K_RIGHT:

						if posicao_jogador_eixo_x < 680 -(nave.get_size()[1]*1.2):

							posicao_jogador_eixo_x = posicao_jogador_eixo_x + 10

					if acontecimentos.key == K_ESCAPE:

						exit()

					if acontecimentos.key == K_F1:

						audio.stop() # Repetição infinita da musica
						main()
		
				if acontecimentos_do_tiro_jogador_jogador[K_SPACE]: # Definimos o botão para esta condição

					somtiro1.play()
					tiro_jogador_p_eixo_y, tiro_jogador_p_eixo_x = posicao_jogador_eixo_y, posicao_jogador_eixo_x

	      				while tiro_jogador_p_eixo_y >= 0: # O tiro_jogador chega até a posição 0 no eixo y. 

						tela.blit(tiro_jogador, (tiro_jogador_p_eixo_x+32,tiro_jogador_p_eixo_y-40)) # Carregando o tiro_jogador, de acordo com a centralização da nave.
						tiro_jogador_p_eixo_y = tiro_jogador_p_eixo_y - velocidade_do_tiro_jogador # Velocidade do tiro_jogador.

	                      			if posicao_inimigo_eixo_x-40 < tiro_jogador_p_eixo_x < posicao_inimigo_eixo_x+40 and tiro_jogador_p_eixo_y < posicao_inimigo_eixo_y+20:#determinando a condição da colisão. ## posicao_inimigo_eixo_y+20 = é a posição da nave inimiga 		                			tela.blit(fundo, (0,0)) #Carrega o fundo, com a mesma resolução da tela.
       	      					
							vida_do_inimigo = vida_do_inimigo - 5
							contador_de_pontos = contador_de_pontos + 1
							tela.blit(inimigo_explo,(posicao_inimigo_eixo_x,posicao_inimigo_eixo_y)) # Desenha a explosão inimigo ao coledir com o tiro_jogador.
							pygame.display.update() # pygame.display.flip().

							break

						else:

							tela.blit(fundo, (0,0))
							pygame.display.update() # pygame.display.flip().
											
				vida_do_inimigoo = tamanho2.render(str(vida_do_inimigo), 1, branco) # Determina tamanho,transforma inteiro em string e determina a cor. 
				pontos1 = tamanho2.render(str(contador_de_pontos), 1, branco) # Determina tamanho,transforma inteiro em string e determina a cor. 	
				tela.fill((0,0,0)) # Preencha a tela, de cor preta (0, 0, 0).
				move_and_draw_stars(tela) # Desenha as estrelas do fundo na tela.
				tela.blit(nave, (posicao_jogador_eixo_x,posicao_jogador_eixo_y)) # Desenha a nave na posição x e y.
				pygame.mouse.set_visible (0) # Invisibilidade do mouse ## Se o argumento booleano é verdade, o cursor do mouse será visível se nao invisível.
				tela.blit(vida_do_inimigoo0,(485,0)) # Conta de vida_do_inimigo 
				tela.blit(vida_do_inimigoo,(610,0)) # contador de vida_do_inimigo
				tela.blit(pontos,(0,0)) # Contador de pontos
				tela.blit(pontos1,(70,0)) # Contador de pontos 
				tela.blit(vida_do_jogadorr,(610,460)) # Contador de pontos de vida do jogador
				tela.blit(pontos_vida2,(500,460)) # Contador de pontos de vida do jogador
				tela.blit(relogio_do_jogo,(60,460))
				tela.blit(contador_tempo,(1,460))
				tela.blit(tempo_do_jogo,(270,180)) 
				tela.blit(fim_do_jogo_vitoria,(130,150))
				tela.blit(fim_do_jogo_vitoria1,(195,180))
				tela.blit(fim_do_jogo_vitoria2,(335,180))
				tela.blit(fim_do_jogo_vitoria3,(132,210))
				pygame.display.update() # pygame.display.flip().
										
		relogio = relogio + 1		
		relogio_do_jogo = tamanho2.render(str(relogio), 1, branco)
		tempo_do_jogo = tamanho3.render(str(relogio), 1, branco)
		vida_do_jogadorr = tamanho2.render(str(vida_do_jogador), 1, branco)
		vida_do_inimigoo = tamanho2.render(str(vida_do_inimigo), 1, branco) # Determina tamanho,transforma inteiro em string e determina a cor. 
       		pontos1 = tamanho2.render(str(contador_de_pontos), 1, branco) # Determina tamanho,transforma inteiro em string e determina a cor. 
		tela.fill((0,0,0)) # Preencha a tela, de cor preta (0, 0, 0).
		move_and_draw_stars(tela) # Desenha as estrelas do fundo na tela.
		tela.blit(inimigo,(posicao_inimigo_eixo_x,posicao_inimigo_eixo_y))# Desenha o inimigo.
		tela.blit(nave, (posicao_jogador_eixo_x,posicao_jogador_eixo_y)) # Desenha a nave na posição x e y.
 		pygame.mouse.set_visible (0) # Invisibilidade do mouse ## Se o argumento booleano é verdade, o cursor do mouse será visível se nao invisível.
		tela.blit(vida_do_inimigoo0,(485,0)) # Conta de vida_do_inimigo 
		tela.blit(vida_do_inimigoo,(610,0)) # contador de vida_do_inimigo
		tela.blit(pontos,(0,0)) # Contador de pontos
		tela.blit(pontos1,(70,0)) # Contador de pontos 
		tela.blit(vida_do_jogadorr,(610,460)) # Contador de pontos de vida do jogador
		tela.blit(pontos_vida2,(500,460)) # Contador de pontos de vida do jogador
		tela.blit(relogio_do_jogo,(60,460))	
		tela.blit(contador_tempo,(1,460))
 		pygame.display.update() # pygame.display.flip().
		pygame.time.wait(0)#pausa o programa para uma quantidade de tempo

		
if __name__ == "__main__":

	main()

